Necessary test cases for Decision Coverage and Modified Condition / Decision Coverage

Test coverage refers to the extent to which a given software verification activity satisfies its objectives. Several types of coverage analysis exist to check code correctness. Less strict analysis methods require fewer test cases to satisfy their requirements and consume less resources. Choosing test methods is a compromise between the code correctness and the available resources. However this selection should be based on quantitative consideration. In this paper we concern the Decision Coverage and the more strict Modified Condition / Decision Coverage. We examined several projects written in Ada programming language. Some of them are developed in the industry and the others are open source. We analyzed them in several aspects: Mc- Cabe metric, nesting and maximal argument number in decisions. We discuss how these aspects are affected by difference of the necessary test cases for these testing methods

4D Ariadne the Static Debugger of Java Programs

Development environments support the programmer in numerous ways from syntax highlighting to different refactoring and code generating methods. However, there are cases where these tools are limited or not usable, such as getting familiar with large and complex source codes written by a third person; finding the complexities of huge projects or finding semantic errors.In this paper we present our static analyzer tool, called 4D Ariadne, which concentrates on these problems. 4D Ariadne is a static debugger of Object Oriented applications written in Java programming language. It calculates data dependencies of objects being able to compute them both forward and backward. As 4D Ariadne provides only the direct influences to the user, it can be considered as an alternative of traditional debuggers, without executing the code. 4D Ariadne also provides dynamic call graphs representing polymorphic properties of objects

Subtle Methods in C++

Nowadays complex software systems are designed and implemented with the help of the object-oriented paradigm principally. However, object-oriented languages support the object-oriented paradigm in different ways with different constructs. C++ has a sophisticated inheritence notation based on access modifiers. C++ distinguishes virtual, pure virtual and non-virtual methods. Java uses final classes and methods to disable inheritance. However, Java does not support multiple inheritance. Eiffel allows renaming inherited methods. In this paper we present some method utilites for C++ to create safer and more flexible object-oriented systems. We present how the method renaming can be implemented. We developed constructs to create final and unhidable methods. These constructs are implemented with the help of C++ template facilities. We present scenarios where one can write safer code with our constructs

C++ exam methodology

The C++ programming language supports multiparadigm programming. We can write programs in procedural, object-oriented, generic way at the same time. However, it is difficult to figure out exercises for the terminal examinations since not easy to separate the algorithmic cogitation from the knowledge of the programming language. There are some basic elements that programmer students have to know: constructors, parameter passing, objects, inheritance, standard library, handling constants, copying objects, functions and member functions, etc. Exercises must be multiparadigm according to the C++ language. Using only one paradigm in C++ is not enough. This results in that we have to distinguish the different linguistic constructs on the basis of its complexity. Many questions are arisen in connection with the exercises of terminal examinations. How can we gauge the procedural, the object-oriented, and the generic paradigms at the same time? How can we gauge students’ C++ knowledge when we do not lay stress on the algorithmic cogitation? What kind of exercises may be interesting by the Standard Template Library? Which C++ constructs are reckoned to be more difficult and which ones considered to be easier? What are the most important ones? In this paper we give answers to the previous questions, we describe our methodology to assessment of students’ C++ knowledge in a semi-automatic grading way. We also present exercise examples that worked out according to our methodology. We take stock of students’ results in the paper

High-level Multicore Programming with C++11

Nowadays, one of the most important challenges in programming is the efficient usage of multicore processors. All modern programming languages support multicore programming at native or library level. C++11, the next standard of the C++ programming language, also supports multithreading at a low level. In this paper we argue for some extensions of the C++ Standard Template Library based on the features of C++11. These extensions enhance the standard library to be more powerful in the multicore realm. Our approach is based on functors and lambda expressions, which are major extensions in the language. We contribute three case studies: how to efficiently compose functors in pipelines, how to evaluate boolean operators in parallel, and how to efficiently accumulate over associative functors

C++ Standard Template Library by infinite iterators

The C++ Standard Template Library (STL) is an essential part of pro- fessional C++ programs. STL is a type-safe template library that is based on the generic programming paradigm and helps to avoid some possible dangerous C++ constructs. With its usage, the efficiency, safety and quality of the code is increased. However, professional C++ programmers are eager for some missing STLrelated opportunities. For instance, infinite ranges are hardly supported by C++ STL. STL does not contain iterators that use a predicate during traversal. STL’s design is not good at all from the view of predicates. In this paper we present some extensions of C++ STL that supports effective generic programming. We show scenarios where these extensions can be used pretty gracefully. We present the implementation of our infinite iterators

COMPARISON OF DC AND MC/DC CODE COVERAGES

ABSTRACT In software development testing plays the most important role to discover bugs and to verify that the product meets its requirements. This paper focuses on programs written in C++ programming language and analyses two important testing methods, the Decision Coverage and the more strict Modified Condition / Decision Coverage. We examine how the program characteristics -lines of code, McCabe metric, the number of the arguments in the decisions, deepness of the nested block -affect the number of necessary test cases of these testing methods. Choosing test methods is always a compromise between the code correctness and the available resources. Less strict ones require fewer test cases and consume less resources, however, they may discover fewer errors. Our results may help to chose between Decision Coverage and Modified Condition / Decision coverage